home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 1999 #2 / Amiga Plus CD - 1999 - No. 2.iso / System-Boost / Workbench / ToolManager / Source / Prefs / popasl.c < prev    next >
C/C++ Source or Header  |  1998-06-17  |  6KB  |  247 lines
  1. /*
  2.  * popasl.c  V3.1
  3.  *
  4.  * PopASL class
  5.  *
  6.  * Copyright (C) 1990-98 Stefan Becker
  7.  *
  8.  * This source code is for educational purposes only. You may study it
  9.  * and copy ideas or algorithms from it for your own projects. It is
  10.  * not allowed to use any of the source codes (in full or in parts)
  11.  * in other programs. Especially it is not allowed to create variants
  12.  * of ToolManager or ToolManager-like programs from this source code.
  13.  *
  14.  */
  15.  
  16. #include "toolmanager.h"
  17.  
  18. /* Local data */
  19. static struct SignalSemaphore CounterSemaphore;
  20. static ULONG                  RequesterCounter;
  21.  
  22. /* Update counter */
  23. static void UpdateCounter(LONG delta)
  24. {
  25.  /* Requester open, lock semaphore */
  26.  ObtainSemaphore(&CounterSemaphore);
  27.  
  28.  /* Increment counter */
  29.  RequesterCounter += delta;
  30.  
  31.  /* Release semaphore */
  32.  ReleaseSemaphore(&CounterSemaphore);
  33. }
  34.  
  35. /* PopASL class instance data */
  36. struct PopASLClassData {
  37.  Object *pacd_Button;
  38. };
  39. #define TYPED_INST_DATA(cl, o) ((struct PopASLClassData *) INST_DATA((cl), (o)))
  40.  
  41. /* PopASL class method: OM_NEW */
  42. #define DEBUGFUNCTION PopASLClassNew
  43. static ULONG PopASLClassNew(Class *cl, Object *obj, struct opSet *ops)
  44. {
  45.  POPASL_LOG((LOG1(Tags, "0x%08lx", ops->ops_AttrList),
  46.                   PrintTagList(ops->ops_AttrList)))
  47.  
  48.  if (obj = (Object *) DoSuperNew(cl, obj, TAG_MORE, ops->ops_AttrList)) {
  49.   struct PopASLClassData *pacd = TYPED_INST_DATA(cl, obj);
  50.  
  51.   /* Get pointer to button */
  52.   GetAttr(MUIA_Popstring_Button, obj, (ULONG *) &pacd->pacd_Button);
  53.  }
  54.  
  55.  POPASL_LOG(LOG1(Result, "0x%08lx", obj))
  56.  
  57.  /* Return pointer to created object */
  58.  return((ULONG) obj);
  59. }
  60.  
  61. /* PopASL class method: OM_DISPOSE */
  62. #undef  DEBUGFUNCTION
  63. #define DEBUGFUNCTION PopASLClassDispose
  64. static ULONG PopASLClassDispose(Class *cl, Object *obj, Msg msg)
  65. {
  66.  ULONG active;
  67.  
  68.  POPASL_LOG(LOG1(Disposing, "0x%08lx", obj))
  69.  
  70.  /* Check requester status */
  71.  GetAttr(MUIA_Popasl_Active, obj, &active);
  72.  
  73.  /* Requester opened? */
  74.  if (active) {
  75.  
  76.   POPASL_LOG(LOG0(Requester still open))
  77.  
  78.   /* Decrement counter */
  79.   UpdateCounter(-1);
  80.  }
  81.  
  82.  /* Call SuperClass */
  83.  return(DoSuperMethodA(cl, obj, msg));
  84. }
  85.  
  86. /* PopASL class method: OM_SET */
  87. #undef  DEBUGFUNCTION
  88. #define DEBUGFUNCTION PopASLClassSet
  89. static ULONG PopASLClassSet(Class *cl, Object *obj, struct opSet *ops)
  90. {
  91.  struct TagItem *tstate = ops->ops_AttrList;
  92.  struct TagItem *ti;
  93.  
  94.  POPASL_LOG((LOG1(Tags, "0x%08lx", ops->ops_AttrList),
  95.                   PrintTagList(ops->ops_AttrList)))
  96.  
  97.  /* Scan tag list */
  98.  while (ti = NextTagItem(&tstate))
  99.  
  100.   /* Which attribute shall be set? */
  101.   switch (ti->ti_Tag) {
  102.    case TMA_ButtonDisabled:
  103.     SetDisabledState(TYPED_INST_DATA(cl, obj)->pacd_Button, ti->ti_Data);
  104.     break;
  105.   }
  106.  
  107.  /* Call SuperClass */
  108.  return(DoSuperMethodA(cl, obj, (Msg) ops));
  109. }
  110.  
  111. /* PopASL class method: MUIM_Popstring_Open */
  112. #undef  DEBUGFUNCTION
  113. #define DEBUGFUNCTION PopASLClassOpen
  114. static ULONG PopASLClassOpen(Class *cl, Object *obj, Msg msg)
  115. {
  116.  ULONG active;
  117.  
  118.  POPASL_LOG(LOG0(Entry))
  119.  
  120.  /* Call SuperClass */
  121.  DoSuperMethodA(cl, obj, msg);
  122.  
  123.  /* Check requester status */
  124.  GetAttr(MUIA_Popasl_Active, obj, &active);
  125.  
  126.  /* Requester opened? */
  127.  if (active) {
  128.  
  129.   POPASL_LOG(LOG0(Requester open))
  130.  
  131.   /* Set window to sleep */
  132.   SetAttrs(_win(obj), MUIA_Window_Sleep, TRUE, TAG_DONE);
  133.  
  134.   /* Increment counter */
  135.   UpdateCounter(1);
  136.  }
  137.  
  138.  /* Return 1 to indicate that the method is implemented */
  139.  return(1);
  140. }
  141.  
  142. /* PopASL class method: MUIM_Popstring_Close */
  143. #undef  DEBUGFUNCTION
  144. #define DEBUGFUNCTION PopASLClassClose
  145. static ULONG PopASLClassClose(Class *cl, Object *obj, Msg msg)
  146. {
  147.  POPASL_LOG(LOG0(Entry))
  148.  
  149.  /* Set window to active */
  150.  SetAttrs(_win(obj), MUIA_Window_Sleep, FALSE, TAG_DONE);
  151.  
  152.  /* Decrement counter */
  153.  UpdateCounter(-1);
  154.  
  155.  /* Call SuperClass */
  156.  return(DoSuperMethodA(cl, obj, msg));
  157. }
  158.  
  159. /* PopASL class method dispatcher */
  160. #undef  DEBUGFUNCTION
  161. #define DEBUGFUNCTION PopASLClassDispatcher
  162. __geta4 static ULONG PopASLClassDispatcher(__a0 Class *cl, __a2 Object *obj,
  163.                                            __a1 Msg msg)
  164. {
  165.  ULONG rc;
  166.  
  167.  POPASL_LOG(LOG3(Arguments, "Class 0x%08lx Object 0x%08lx Msg 0x%08lx",
  168.                     cl, obj, msg))
  169.  
  170.  switch(msg->MethodID) {
  171.   /* BOOPSI methods */
  172.   case OM_NEW:
  173.    rc = PopASLClassNew(cl, obj, (struct opSet *) msg);
  174.    break;
  175.  
  176.   case OM_DISPOSE:
  177.    rc = PopASLClassDispose(cl, obj, msg);
  178.    break;
  179.  
  180.   case OM_SET:
  181.    rc = PopASLClassSet(cl, obj, (struct opSet *) msg);
  182.    break;
  183.  
  184.   /* MUI methods */
  185.   case MUIM_Popstring_Open:
  186.    rc = PopASLClassOpen(cl, obj, msg);
  187.    break;
  188.  
  189.   case MUIM_Popstring_Close:
  190.    rc = PopASLClassClose(cl, obj, msg);
  191.    break;
  192.  
  193.   /* Unknown method -> delegate to SuperClass */
  194.   default:
  195.    rc = DoSuperMethodA(cl, obj, msg);
  196.    break;
  197.  }
  198.  
  199.  return(rc);
  200. }
  201.  
  202. /* Create PopASL class */
  203. #undef  DEBUGFUNCTION
  204. #define DEBUGFUNCTION CreatePopASLClass
  205. struct MUI_CustomClass *CreatePopASLClass(void)
  206. {
  207.  struct MUI_CustomClass *rc;
  208.  
  209.  /* Create class */
  210.  if (rc = MUI_CreateCustomClass(NULL, MUIC_Popasl, NULL,
  211.                                 sizeof(struct PopASLClassData),
  212.                                 PopASLClassDispatcher)) {
  213.  
  214.   /* Initialize requester counter semaphore */
  215.   InitSemaphore(&CounterSemaphore);
  216.  
  217.   /* Initialize requester counter */
  218.   RequesterCounter = 0;
  219.  }
  220.  
  221.  POPASL_LOG(LOG1(Result, "0x%08lx", rc))
  222.  
  223.  return(rc);
  224. }
  225.  
  226. /* Show error requester and return FALSE if an ASL requester is still  open */
  227. #undef  DEBUGFUNCTION
  228. #define DEBUGFUNCTION CheckRequesters
  229. BOOL CheckRequesters(Object *win)
  230. {
  231.  BOOL rc;
  232.  
  233.  /* Still requesters open? */
  234.  if ((rc = (RequesterCounter == 0)) == FALSE)
  235.  
  236.   /* Show error requester */
  237.   MUI_RequestA(_app(win), win, 0,
  238.                TextGlobalTitle, TextGlobalCancel,
  239.                TranslateString(LOCALE_TEXT_POPASL_CLOSE_DELAYED_STR,
  240.                                LOCALE_TEXT_POPASL_CLOSE_DELAYED),
  241.                NULL);
  242.  
  243.  POPASL_LOG(LOG1(Result, "%ld", rc))
  244.  
  245.  return(rc);
  246. }
  247.